package com.dkd.manage.service.impl;

import com.dkd.common.exception.ServiceException;
import com.dkd.common.utils.DateUtils;
import com.dkd.manage.domain.Order;
import com.dkd.manage.mapper.OrderMapper;
import com.dkd.manage.service.IOrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;

/**
 * 订单管理Service业务层处理
 * 
 * @author CoCo
 * @date 2025-02-04
 */
@Service
public class OrderServiceImpl implements IOrderService 
{
    @Autowired
    private OrderMapper orderMapper;

    /**
     * 查询订单管理
     * 
     * @param id 订单管理主键
     * @return 订单管理
     */
    @Override
    public Order selectOrderById(Long id)
    {
        return orderMapper.selectOrderById(id);
    }

    /**
     * 查询订单管理列表
     * 
     * @param order 订单管理
     * @return 订单管理
     */
    @Override
    public List<Order> selectOrderList(Order order)
    {
        // 获得order的params
        Map<String, Object> params = order.getParams();
        Object createTime = params.get("beginTime");
        Object endTime = params.get("endTime");
        if (createTime != null && endTime != null) {
            // 获取params中的createTime和endTime
            String createTimeStr = (String) createTime;
            String endTimeStr = (String) endTime;
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

            LocalDate startDate = LocalDate.parse(createTimeStr, formatter);
            LocalDate endDate = LocalDate.parse(endTimeStr, formatter);
            // 获取两个日期的时间戳
            // 将LocalDate转换为时间戳（毫秒）
            long startTimeStamp = getEpochMilliFromLocalDate(startDate);
            long endTimeStamp = getEpochMilliFromLocalDate(endDate);

            // 判断createTime和endTime的时间戳是否超过一年
            if (startTimeStamp < endTimeStamp) {
                if (isWithinOneYear(startTimeStamp, endTimeStamp)) {
                    return orderMapper.selectOrderList(order);
                } else {
                    throw new ServiceException("所选的时间范围不能超过一年");
                }
            }else{
                throw new ServiceException("开始时间不能大于结束时间");
            }
        }
        return orderMapper.selectOrderList(order);
    }

    private static long getEpochMilliFromLocalDate(LocalDate localDate) {
        // 将LocalDate转换为当天午夜（00:00:00）的ZonedDateTime对象，默认使用系统默认时区
        ZonedDateTime zonedDateTime = localDate.atStartOfDay(ZoneId.systemDefault());
        // 获取该时间点的Instant对象，并转换为毫秒时间戳
        return zonedDateTime.toInstant().toEpochMilli();
    }

    public static boolean isWithinOneYear(long startTimeStamp, long endTimeStamp) {
        // 将毫秒时间戳转换为Instant对象
        Instant start = Instant.ofEpochMilli(startTimeStamp);
        Instant end = Instant.ofEpochMilli(endTimeStamp);

        // 计算两个Instant对象之间的时间差
        Duration duration = Duration.between(start, end);

        // 获取时间差的总秒数，并与一年的秒数进行比较
        // 使用普通年份的秒数31,536,000秒作为标准，如果需要考虑闰年可以使用31,622,400秒
        long diffInSeconds = Math.abs(duration.getSeconds());

        // 普通年：31,536,000秒
        final long ONE_YEAR_IN_SECONDS = 31_536_000L;

        return diffInSeconds <= ONE_YEAR_IN_SECONDS;
    }

    /**
     * 新增订单管理
     * 
     * @param order 订单管理
     * @return 结果
     */
    @Override
    public int insertOrder(Order order)
    {
        order.setCreateTime(DateUtils.getNowDate());
        return orderMapper.insertOrder(order);
    }

    /**
     * 修改订单管理
     * 
     * @param order 订单管理
     * @return 结果
     */
    @Override
    public int updateOrder(Order order)
    {
        order.setUpdateTime(DateUtils.getNowDate());
        return orderMapper.updateOrder(order);
    }

    /**
     * 批量删除订单管理
     * 
     * @param ids 需要删除的订单管理主键
     * @return 结果
     */
    @Override
    public int deleteOrderByIds(Long[] ids)
    {
        return orderMapper.deleteOrderByIds(ids);
    }

    /**
     * 删除订单管理信息
     * 
     * @param id 订单管理主键
     * @return 结果
     */
    @Override
    public int deleteOrderById(Long id)
    {
        return orderMapper.deleteOrderById(id);
    }
}
